{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = np.sin(x_mesh+y_mesh*5)+np.exp(-x_mesh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.contour.QuadContourSet at 0x1ca469f05e0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.contourf(x_domain, y_domain, truth_smooth,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = truth_smooth + np.random.normal(loc=0.0, scale=0.3, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07129772007673647"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean((uxy[0,:,:,0]-truth_data)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth':np.asarray(truth_smooth),\n",
    "                     'samples':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0)}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
